package com.xuecheng.content.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xuecheng.api.content.model.dto.CourseBaseDTO;
import com.xuecheng.api.content.model.qo.QueryCourseBaseModel;
import com.xuecheng.common.domain.code.CommonErrorCode;
import com.xuecheng.common.domain.page.PageRequestParams;
import com.xuecheng.common.domain.page.PageVO;
import com.xuecheng.common.enums.common.CommonEnum;
import com.xuecheng.common.enums.content.CourseAuditEnum;
import com.xuecheng.common.enums.content.CourseChargeEnum;
import com.xuecheng.common.exception.ExceptionCast;
import com.xuecheng.common.util.StringUtil;
import com.xuecheng.content.common.constant.ContentErrorCode;
import com.xuecheng.content.convert.CourseBaseConvert;
import com.xuecheng.content.entity.CourseBase;
import com.xuecheng.content.entity.CourseMarket;
import com.xuecheng.content.mapper.CourseBaseMapper;
import com.xuecheng.content.service.CourseBaseService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;

import java.math.BigDecimal;
import java.util.Collections;
import java.util.Date;
import java.util.List;

/**
 * <p>
 * 课程基本信息 服务实现类
 * </p>
 *
 * @author itcast
 */
@Slf4j
@Service
public class CourseBaseServiceImpl extends ServiceImpl<CourseBaseMapper, CourseBase> implements CourseBaseService {
    @Autowired
    private CourseMarketServiceImpl courseMarketService;

    /*todo 分页条件查询
        步骤分析:
                 1是否需要开启事物
                 2判断条件:
                      分页条件:
                      查询条件
                 3 构建mp分页对象
                 4构建查询条件 LambdaQueryWrapper对象
                 5 查询数据
                 6 获取数据并封装返回
                    将查询到的pojo数据转换成PageVo对象响应给前端
                   PageVO 对象中封装着前端需要的数据,pojo实体中数据过多
     */
    @Override
    //@Transactional//开启事物  作用事务就是对一系列的数据库操作进行统一的提交或回滚操作  事物统一处理,要么都失败要么都成功,例如转账
    public PageVO queryCourseBaseList(PageRequestParams params, QueryCourseBaseModel model, Long companyId) {
//todo 1 是否需要开启事物
                    /*
                     Springboot开启事物直接在方法上添加注解@Transactional
                     注意:不是所有方法都要添加事物,所有查询是不需要添加事物的
                     */
//todo 2判断条件:
        //todo 2.1 分页条件:
        Long pageNo = params.getPageNo();
        Integer pageSize = params.getPageSize();
                                                        /*
                                                        ObjectUtils 导入的包是springframework.util
                                                         */
        if (ObjectUtils.isEmpty(pageNo) || pageNo < 0) {
            //判断页数是否为空,为空就把默认值赋值进去
            params.setPageNo(PageRequestParams.DEFAULT_PAGE_NUM);
        }
        if (ObjectUtils.isEmpty(pageSize) || pageSize < 0) {
            //判断每页条数是否为空,为空就把默认值赋值进去
            params.setPageSize(PageRequestParams.DEFAULT_PAGE_SIZE);
        }
        //todo 2.2 构建查询条件 (分页查询的条件)
        LambdaQueryWrapper<CourseBase> queryWrapper = new LambdaQueryWrapper<>();
        if (StringUtil.isNotBlank(model.getCourseName())) {
            //判断课程名称不为空,将前端传的参数添加进queryWrapper,  课程名称用like模糊查询
            queryWrapper.like(CourseBase::getName, model.getCourseName());
        }
        if (StringUtil.isNotBlank(model.getAuditStatus())) {
            //判断课程审核状态不为空,将前端传的参数添加进queryWrapper
            queryWrapper.eq(CourseBase::getAuditStatus, model.getAuditStatus());
        }
        //判断companyId 机构id是否为空,为空就不加入条件,不为空就加入条件进行查询
        if(!(ObjectUtils.isEmpty(companyId))){
            queryWrapper.eq(CourseBase::getCompanyId, companyId);//根据机构id获取相应的机构数据,实现数据分隔
        }

        queryWrapper.eq(CourseBase::getStatus, CommonEnum.USING_FLAG.getCode());

                                   /*
                                    简化判断 queryWrapper.eq(boolean,条件)  说明  当是true时条件执行
                                   queryWrapper.eq(StringUtil.isNotBlank(model.getCourseName()),CourseBase::getName,model.getCourseName());
                                   queryWrapper.eq(StringUtil.isNotBlank(model.getAuditStatus()),CourseBase::getAuditStatus,model.getAuditStatus());
                                    */
//todo 3 构建mp分页对象 page是分页对象
        Page<CourseBase> page = new Page<>(params.getPageNo(), params.getPageSize());
/*  todo 5 查询数据
                    this 指当前service继承ServiceImpl, ServiceImpl 底层继承了 IService
                     this.page是调用IService中的page(分页对象,分页查询条件)方法
         */
        Page<CourseBase> pageResult = this.page(page, queryWrapper);
        //数据集合,集合中的数据都是pojo类型,要转成dto
        List<CourseBase> records = pageResult.getRecords();
        //查询数据的总条数
        long total = pageResult.getTotal();
 /*todo 6 获取数据并封装返回
                将查询到的pojo数据转换成PageVo对象响应给前端
                PageVO 对象中封装着前端需要的数据,pojo实体中数据过多*/
        List<CourseBaseDTO> dtos = Collections.EMPTY_LIST;

        if (!(CollectionUtils.isEmpty(records))) {
                                                    /*
                                                    todo
                                                    CourseBaseConvert 自定义接口 是个转换器 讲pojo转成dto
                                                    INSTANCE 表示获取CourseBaseConvert接口的实现类,在接口中定义了
                                                    entitys2dtos pojo集合转dto集合的方法
                                                     */
            dtos = CourseBaseConvert.INSTANCE.entitys2dtos(records);
        }
        //  将数据封装成PageVO 对象,响应给前端
        PageVO pageVO = new PageVO(dtos, total, params.getPageNo(), params.getPageSize());
        return pageVO;
    }


    /* todo 课程信息添加
         步骤分析:
                1 是否需要开启事物
                    新增业务需要开启事物
                    新增如果是对一张表进行操作,只操作一次,可以省略掉事物
                2 判断前段传入的条件中的关键数据
                          关键数据:前端页面必须要有的数据,要是没有说明数据不完整
                          关键数据来源:
                                     - 1 数据库的约束:
                                            数据库表的一些字段不能为空
                                     - 2  前端页面中必要数据
                                            本项目在前端页面用小红点标注
                                     - 3   接口文档 Yapi
                                            会体现出必要的数据(前后端都可以看懂)
                3 将dto 数据转成 po 数据,并添加课程信息的状态
                        保存:未提交状态
                4 对数据库进行操作保存数据
                          4.1 课程信息添加
                                判断该操作是否成功
                          4.2  课程价格添加
                                判断该操作是否成功
                5 将po数据转成dto数据响应给前端
     */
    @Override
    @Transactional //开启事物
    public CourseBaseDTO creatCourseBase(CourseBaseDTO dto) {
//todo  2 判断前段传入的条件中的关键数据
// 关键数据:前端页面必须要有的数据,要是没有说明数据不完整
        verifyCourseMsg(dto); //方法引用

//todo 3 将dto 数据转成 po 数据,并添加课程信息的状态

        CourseBase courseBase = CourseBaseConvert.INSTANCE.dto2entity(dto);
        // 添加保存状态:未提交状态
        courseBase.setAuditStatus(CourseAuditEnum.AUDIT_UNPAST_STATUS.getCode());

//todo 4 对数据库进行操作保存数据
        //todo 4.1 课程信息添加
        boolean baseResult = this.save(courseBase);
        //判断该操作是否成功
        if (!baseResult) {
            //保存课程信息失败
            ExceptionCast.cast(ContentErrorCode.E_120001);
        }
        //todo   4.2  课程价格添加
        CourseMarket courseMarket = new CourseMarket();
        courseMarket.setCharge(dto.getCharge());//添加课程收费状态
        //todo 4.2.1先判断价格是否免费,只有不免费才可以添加价格
        if (CourseChargeEnum.CHARGE_YES.getCode().equals(dto.getCharge())) {
            //todo 4.2.2不免费价格不能为空,因此必须对价格作出判断
            if (ObjectUtils.isEmpty(dto.getPrice())) {

                //收费课程的价格不能为空
                ExceptionCast.cast(ContentErrorCode.E_120019);
            }
        }
        courseMarket.setPrice(dto.getPrice().floatValue());  //dto和po中该属性的类型不同因此需要转换
        courseMarket.setCourseId(courseBase.getId());//添加机构id
        //todo 4.3添加数据并做判断
        boolean marketResult = courseMarketService.save(courseMarket);
        if (!marketResult) {
            //添加价格失败
            ExceptionCast.cast(ContentErrorCode.E_120107);

        }

// todo 5 将po数据转成dto数据响应给前端
        CourseBaseDTO courseBaseDTO = CourseBaseConvert.INSTANCE.entity2dto(courseBase);
        return courseBaseDTO;
    }

    /*todo   修改课程数据 根据id查询数据并返回前端进行修改
     * 业务分析：
     *   1.判断关键数据
     *       courseId、companyId
     *   2.判断业务数据
     *       课程基础信息
     *           课程是否是同一家教学机构
     *           判断课程是否已删除
     *   3.将数据转为dto并返回
     * */

    @Override
    public CourseBaseDTO getCourseById(Long courseBaseId, Long companyId) {
        //todo   1.判断关键数据   courseId、companyId
        if (ObjectUtils.isEmpty(courseBaseId) ||
                ObjectUtils.isEmpty(companyId)
        ) {
            throw new RuntimeException(CommonErrorCode.E_100101.getDesc());
        }
        //todo *   2.判断业务数据
        CourseBase courseBase = getCourseBaseAndLogicVerify(courseBaseId, companyId);
        //todo 3.将数据转为dto并返回
        CourseBaseDTO dto = CourseBaseConvert.INSTANCE.entity2dto(courseBase);
        //todo 3.1查询课程是否免费以及价格
        LambdaQueryWrapper<CourseMarket> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //todo 3.2上面根据id可以查询到数据,直接获取到课程的销售信息
        lambdaQueryWrapper.eq(CourseMarket::getCourseId, courseBaseId);
        CourseMarket courseMarket = courseMarketService.getOne(lambdaQueryWrapper);
        //todo 判断课程价格是否为空,为空直接返回免费
        if (ObjectUtils.isEmpty(courseMarket)) {
            dto.setCharge(CourseChargeEnum.CHARGE_NO.getCode());
            return dto;
        }
        //todo 3.3将课程是否免费注入到dto中返回前端
        dto.setCharge(courseMarket.getCharge());
        dto.setPrice(new BigDecimal(courseMarket.getPrice().toString()));
        return dto;
    }


    /*todo 修改课程信息
     *   1.判断关键数据
     *      参考添加的判断
     *   2.判断业务数据
     *       课程基础信息
     *           判断是否是同一家教学机构
     *           判断课程是否被删除
     *           判断课程的审核状态
     *               只有 未提交、审核未通过 才可以修改数据
     *   3.转换dto数据为po数据
     *   4.修改数据
     *       课程基础信息
     *       课程营销信息
     *   5.将最新数据返回给dto
     * */
    @Override
    public CourseBaseDTO modifyCourseResult(CourseBaseDTO dto) {
// todo 1.判断关键数据
        verifyCourseMsg(dto);
        if (ObjectUtils.isEmpty(dto.getCompanyId())
        ) {
            //教学机构ID不能为空
            ExceptionCast.cast(CommonErrorCode.E_110009);

        }
//todo 2.判断业务数据
// 判断是否是同一家教学机构   判断课程是否被删除 ,  调用方法进行判断
        // todo 2.1判断课程的审核状态   注意 :只有 未提交、审核未通过 才可以修改数据
        getReasonableCourseBase(dto.getCourseBaseId(), dto.getCompanyId());
// todo 3.转换dto数据为po数据
        CourseBase po = CourseBaseConvert.INSTANCE.dto2entity(dto);
// todo 4.修改数据
// todo 4.1修改课程基础信息    注意 如果修改的实体数据比较多，updateById（要修改的实体类对象）
        boolean b = this.updateById(po);
        if (!b) {
            //修改课程基础信息失败
            ExceptionCast.cast(ContentErrorCode.E_120017);

        }
//todo 4.2修改课程营销信息(就是课程是否免费以及价格)  注意如果修改的实体数据比较少，LambdaUpdateWrapper
        // sql语句修改格式  update course_market set charge = ? ,  price = ? where courseid =?
        LambdaUpdateWrapper<CourseMarket> updateWrapper = new LambdaUpdateWrapper<>();
        //todo 4.2.1 获取课程是否免费
        String charge = dto.getCharge();
        //将课程是否免费加入条件
        updateWrapper.set(CourseMarket::getCharge, charge);
        //判断课程是否免费是否
        if (CourseChargeEnum.CHARGE_NO.getCode().equals(charge)) {
            //免费价格就为0 ,将课程价格加入条件
            updateWrapper.set(CourseMarket::getPrice, 0);
        } else {
            //将课程价格加入条件
            /*
            todo 注意  :  CourseMarket 与  dto 中price属性的类型不同需要转换 ,
                因此dto.getPrice().floatValue()   表示 获取dto中的price,在调用方法 floatValue() 将dto的数据类型转成float
             */
            updateWrapper.set(CourseMarket::getPrice, dto.getPrice().floatValue());
        }
        //将需要根据哪个id修改加入
        updateWrapper.eq(CourseMarket::getCourseId, dto.getCourseBaseId());
        boolean update = courseMarketService.update(updateWrapper);
        if (!update) {
            throw new RuntimeException("修改课程营销失败");
        }
//todo  5.将po最新数据返回给dto
        CourseBaseDTO courseBaseDTO = CourseBaseConvert.INSTANCE.entity2dto(po);
        courseBaseDTO.setCharge(dto.getCharge());
        courseBaseDTO.setPrice(dto.getPrice());
        return courseBaseDTO;
    }


    /*todo 根据id删除
         需求分析:
              1 判断课程,和教学机构id是否正确
              2 判断课程状态,已提交,审核通过,课程已发布,这三种状态无法删除
              3逻辑删除,只是让其查询不到
         */
    @Override
    public void removeCourseBase(Long courseBaseId, Long companyId) {
        //todo 1 判断课程,和教学机构id是否正确
        if (ObjectUtils.isEmpty(courseBaseId)) {
            throw new RuntimeException("课程id不能为空");
        }
        if (ObjectUtils.isEmpty(companyId)) {
            throw new RuntimeException(CommonErrorCode.E_100101.getDesc());
        }
        //todo 2 判断课程状态,已提交,审核通过,课程已发布,这三种状态无法删除
        CourseBase courseBase = this.getById(courseBaseId);
        String auditStatus = courseBase.getAuditStatus();
        if (CourseAuditEnum.AUDIT_COMMIT_STATUS.equals(auditStatus) ||
                CourseAuditEnum.AUDIT_PASTED_STATUS.equals(auditStatus) ||
                CourseAuditEnum.AUDIT_PUBLISHED_STATUS.equals(auditStatus)
        ) {
            throw new RuntimeException("课程审核状态异常,无法删除");
        }
        //todo 3逻辑删除,只是让其查询不到,修改其状态就可以
        //todo 注意这里使用的是LambdaUpdateWrapper
        LambdaUpdateWrapper<CourseBase> queryWrapper = new LambdaUpdateWrapper<>();

        queryWrapper.set(CourseBase::getStatus, CommonEnum.DELETE_FLAG.getCodeInt());
        queryWrapper.eq(CourseBase::getId, courseBaseId);
        //删除课程信息
        boolean update = this.update(queryWrapper);
        if (!update) {
            throw new RuntimeException("删除失败");
        }


    }

    /*todo 课程进行审核提交
          业务分析
               1 判断是否开启事物
               2判断关键数据
               3判断业务数据
                      课程基本信息
                            课程是否存在
                            课程审核状态
                            课程机构是否正确
               4将课程状态改为提交,这样才可以让运行平台进行审核
               5判断是否修改成功

     */
    @Override
    @Transactional   //1 开启事物
    public void submitCourseBase(Long courseBaseId, Long companyId) {
//todo   2判断关键数据
        if (ObjectUtils.isEmpty(courseBaseId) ||
                ObjectUtils.isEmpty(companyId)
        ) {
            throw new RuntimeException(CommonErrorCode.E_100101.getDesc());
        }
/*todo 3判断业务数据
        课程基本信息
       课程是否存在
        课程审核状态
        课程机构是否正确*/
        getReasonableCourseBase(courseBaseId, companyId);
//todo 4将课程状态改为提交,这样才可以让运行平台进行审核
        LambdaUpdateWrapper<CourseBase> updateWrapper = new LambdaUpdateWrapper<>();
        //修改课程的审核状态为已提交
        updateWrapper.set(CourseBase::getAuditStatus,CourseAuditEnum.AUDIT_COMMIT_STATUS.getCode());
        updateWrapper.eq(CourseBase::getId,courseBaseId);
        //todo 5判断是否修改成功
        boolean update = this.update(updateWrapper);
    if(!update){
        ExceptionCast.cast(ContentErrorCode.E_120017);
    }


    }
/*
todo 课程审核
        业务分析:
           判断是否需要开启事物
               1.判断前端传入的关键数据
                     courseId           课程id
                     courseAuditStatus  课程审核状态
                     courseAutditMind   课程审核意见
               2   判断业务数据
                      课程基本信息
                      课程是否存在
                      课程审核状态:只能是已提交才可审核
               3 修改审核数据
                   修改课程审核的数据
                         修改CourseBase表
                         audtiStatus
                         auditMind
                         auditNum
                         changeDate
               4判断审核是否成功
 */
  @Transactional  //
    public void approveCourse(CourseBaseDTO dto) {
     /* todo 1.判断前端传入的关键数据
                      courseId           课程id
                      courseAuditStatus  课程审核状态
                      courseAutditMind   课程审核意见*/
      String auditStatus = dto.getAuditStatus();
      if (ObjectUtils.isEmpty(dto.getCourseBaseId())||
              StringUtil.isBlank(auditStatus)||
              StringUtil.isBlank(dto.getAuditMind())
      ) {
          ExceptionCast.cast(CommonErrorCode.E_100101);
      }
      /*todo  2   判断业务数据
                          课程是否存在
                          课程是否删除(因为是假删除需要判断)
                          课程审核状态:只能是已提交才可审核*/
      CourseBase courseBase = this.getById(dto.getCourseBaseId());

      //todo 2.1判断课程是否存在
      if(ObjectUtils.isEmpty(courseBase)){
          ExceptionCast.cast(ContentErrorCode.E_120013);
      }
      //todo 2.2  判断课程是否删除
      if(CommonEnum.DELETE_FLAG.getCodeInt().equals(dto.getStatus())){
          ExceptionCast.cast(ContentErrorCode.E_120102);
      }
      //todo 2.3课程审核状态:只能是已提交才可审核
      if(!(CourseAuditEnum.AUDIT_COMMIT_STATUS.getCode().equals(courseBase.getAuditStatus()))){
          ExceptionCast.cast(ContentErrorCode.E_120015);
      }
      /*
      todo 3 修改审核数据
                   修改课程审核的数据
                         修改CourseBase表
                         audtiStatus  //审核状态
                         auditMind    //审核意见
                         auditNum   //审核几次
                         changeDate //审核时间
       */
      LambdaUpdateWrapper<CourseBase> updateWrapper = new LambdaUpdateWrapper<>();
      //todo 审核状态
      updateWrapper.set(CourseBase::getAuditStatus,auditStatus);
      //todo 审核意见
      updateWrapper.set(CourseBase::getAuditMind,dto.getAuditMind());
      //todo 审核几次   +1 每审核一次就加 1
          updateWrapper.set(CourseBase::getAuditNums,courseBase.getAuditNums()+1);


      //todo 审核时间   当前审核时间
      updateWrapper.set(CourseBase::getChangeDate,new Date());
      updateWrapper.eq(CourseBase::getId,dto.getCourseBaseId());
      // todo  4判断审核是否完成
      boolean update = this.update(updateWrapper);
      if(!update){
          ExceptionCast.cast(ContentErrorCode.E_120015);
      }

  }

    /*
    todo 判断来自前端页面的(课程信息的)关键字段,  这是代码块
     */
    private void verifyCourseMsg(CourseBaseDTO dto) {
        //  关键字段数据(来自表和前端页面): company_id name mt st grade teachmode Urse audit_status(课程状态在这里定义)
        if (ObjectUtils.isEmpty(dto.getCompanyId())) {
            // 业务异常：程序员在做业务判断时，数据有问题。
            // 异常：
            //    1.终止程序
            //    2.传递错误信息
            //    3.使用运行时异常来抛出
            //        运行时异常不需在编译期间处理
            /*
            todo
                BusinessException,是自定义异常类,但是他传入的对象ErrorCode接口,
                CommonErrorCode(枚举类)实现了ErrorCode接口,
                那么ErrorCode接口相当于CommonErrorCode(枚举类)的父类,
            机构id不能为空
          throw new BusinessException(CommonErrorCode.E_110009);*/
            /*
            ExceptionCast类中的 cast方法封装了  throw new BusinessException(ErrorCode errorCode)
             */
            ExceptionCast.cast(CommonErrorCode.E_110009);
        }
        if (StringUtil.isBlank(dto.getName())) {
            //课程名称不能为空
            ExceptionCast.cast(CommonErrorCode.E_110009);
        }
        if (StringUtil.isBlank(dto.getMt())) {
            // 课程大分类不能为空
            ExceptionCast.cast(ContentErrorCode.E_120004);
        }
        if (StringUtil.isBlank(dto.getSt())) {
            //课程小分类不能为空
            ExceptionCast.cast(ContentErrorCode.E_120003);
        }
        if (StringUtil.isBlank(dto.getGrade())) {
            //课程等级不能为空
            ExceptionCast.cast(ContentErrorCode.E_120007);
        }
        if (StringUtil.isBlank(dto.getTeachmode())) {
            //课程教学模式不能为空
            ExceptionCast.cast(ContentErrorCode.E_120006);
        }
        if (StringUtil.isBlank(dto.getUsers())) {
            //适用人群不能为空
            ExceptionCast.cast(ContentErrorCode.E_120018);
        }
        if (StringUtil.isBlank(dto.getCharge())) {
            //课程价格不能为空
            ExceptionCast.cast(ContentErrorCode.E_120109);

        }
    }

    /*
       todo 判断课程机构是否正确,以及课程是否被删除(代码块)
     */
    private CourseBase getCourseBaseAndLogicVerify(Long courseBaseId, Long companyId) {
        //todo 2.1(判断登录机构是否正确)解析 :将两个条件带入进行查询,如果查询到数据说明条件正确.查询不到数据
        LambdaQueryWrapper<CourseBase> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CourseBase::getCompanyId, companyId);
        queryWrapper.eq(CourseBase::getId, courseBaseId);
        //判断查询到的机构数据,如果是空说明前端传的id不对
        CourseBase courseBase = this.getOne(queryWrapper);
        if (ObjectUtils.isEmpty(courseBase)) {
            //课程基础信息不存在
            ExceptionCast.cast(ContentErrorCode.E_120013);

        }
        //todo 2.2判断课程是否已删除
        Integer status = courseBase.getStatus();//因为上面查询的数正确我可以直接通过程序的数据获取是否被删除,因为是假删除
        if (CommonEnum.DELETE_FLAG.getCodeInt().equals(status)) {
            //课程基础信息不存在
            ExceptionCast.cast(ContentErrorCode.E_120013);
        }

        return courseBase;
    }

    // todo  判断课程机构是否正确,以及课程是否被删除(代码块)   以及课程审核状态
    private void getReasonableCourseBase(Long courseBaseId, Long companyId) {
        CourseBase courseBase =
                getCourseBaseAndLogicVerify(courseBaseId, companyId);
// todo 2.1判断课程的审核状态   注意 :只有 未提交、审核未通过 才可以修改数据
        String auditStatus = courseBase.getAuditStatus();
        if (CourseAuditEnum.AUDIT_COMMIT_STATUS.equals(auditStatus) ||
                CourseAuditEnum.AUDIT_PASTED_STATUS.equals(auditStatus) ||
                CourseAuditEnum.AUDIT_PUBLISHED_STATUS.equals(auditStatus)
        ) {

            //课程审核状态异常"); E_120011
            ExceptionCast.cast(ContentErrorCode.E_120011);
        }
    }
}

